gesture: Handle GDK_TOUCH_CANCEL events

The wayland windowing backend emits such events for instance, so
have gestures cancel the sequence as those events get through.

gesture: Protect against odd window hierarchies

If no match is found with the gesture widget when poking the event
window parents, bail out safely instead of falling in an infinite
loop. This was seen on Mutter.

swipe: Don't emit ::swipe if there are still active touches

Avoids sending spurious signals when an extra touch happens.

Prevent subclassing of gestures

For now, at least. We do this by hiding the instance and
class structures in private headers.

GtkSpinButton: Don't leak the gestures

GtkWindow: Don't leak the gesture

GtkTreeView: Remove unused field

gtk3-demo: Don't leak the color chooser

GtkColorPlane: Actually add the long press gesture

This was missed because gtk_widget_remove_controller silently
does nothing on unowned controllers.

GtkButton: Don't leak the gesture

Forgotten file

GtkButton: Port to GtkGesture

Quick-and-dirty patch to use a GtkGestureSingle for both
button press/release and touch event handling.

widget: remove GtkGesture-related signals

The utility of those signals is somewhat dubious now that there is
gtk_gesture_group(), so make that the only way to coordinate gestures.
The cooperation model offered by gtk_gesture_group() is flexible
enough,

docs: Add missing GtkEventController functions

widget: Add docs for GtkGesture-related API

gesturesingle: doc fixes

zoom: doc fixes

swipe: doc fixes

rotate: doc fixes

pan: doc fixes

multipress: doc fixes

longpress: doc fixes

drag: doc fixes

gesture: doc fixes

eventcontroller: doc fixes

docs: Add missing controller/gesture docs

pan: Add missing documentation

zoom: Add missing documentation

rotate: Add missing documentation

swipe: Add missing documentation

drag: Add missing documentation

longpress: Add missing documentation

multipress: Add missing documentation

gesturesingle: Add missing documentation

gesture: Add missing documentation

eventcontroller: Add missing documentation

enums: Add missing docs to controller/gesture enums

Remove GtkPressAndHold

This is replaced by GtkGestureLongPress, and all its callers have
been updated to use the replacement.

enums: Document GtkPropagationPhase

spinbutton: increase/decrease value on upwards/downwards touch swipes

This is somewhat analogous to scroll events on pointer devices, the
greater the velocity, the faster the spinbutton spins.

Add GtkGesturePan

This gesture reports events on horizontal/vertical panning gestures.

range: Replace GtkPressAndHold with GtkGestureLongPress

swipe: Add function to retrieve the current velocity

This can be used to fetch the current velocity on update(), as opposed
to swipe() which happens after the sequence is finished.

colorswatch: Replace GtkPressAndHold

GtkGestureLongPress and GtkGestureMultiPress are both used
to replace it.

colorscale: Replace GtkPressAndHold with GtkLongPressGesture

colorplane: Replace GtkPressAndHold with GtkLongPressGesture

entry: Don't show text handles too eagerly on button press

Instead do so on button release, or after text selection dragging
starts.

longpress: Ensure check() happens after cancel()

And delegate on GtkGesture::check(), it does deal better with
extra fleeting touches.

longpress: fix reentrancy on ::reset()

gesturemultipress: fix reentrancy on ::reset()

gesturesingle: check the current sequence before resetting the pressed button

scrolledwindow: update to gesture widget-level API changes

window: update to gesture widget-level API changes

treeview: update to gesture widget-level API changes

drag: remove unused #define

eventcontroller: Add documentation blurb

dnd: Update to gesture widget-level API changes

demo: Update to gesture widget-level API changes

widget: refactor gesture integration

Listen for notify::sequence-state-changed on the controller, so the
only way to manipulate a sequence state are gtk_gesture_set_sequence_state()
and gtk_gesture_set_state().

Also, make use of gesture groups, so the sequence state is set at once
on all gestures pertaining to a single group. Within a widget, if a sequence
is claimed on one group, it is made to be denied on every other group.

gesture: Add grouping API

This API eliminates the need for overriding
GtkWidget::sequence-state-changed virtually everywhere. Grouped
gestures share common states for a same GdkEventSequence, so the
state of sequences stay in sync across those.

gesture: Add gtk_gesture_set_state() helper.

This function sets the state on all sequences where it actually
can, just a helper function to avoid iterating over sequences
yourself.

gesture: emit the current state on ::sequence-state-changed

gesture: group continue conditions together

gesture: return TRUE if the sequence state was already set

gesture: fix compiler warning

gesture: ignore events if now widget window was found

eventcontroller: Add propagation-phase property

This is so we don't have to specify the capture phase for
every controller. The default "bubble" value will be sane
on most situations.

treeview: remove superfluous GTK+ grabs

textview: remove superfluous GTK+ grabs

iconview: remove superfluous GTK+ grabs

combobox: remove superfluous GTK+ grabs

cellrendereraccel: remove superfluous GTK+ grabs

Revert "gtk: Remove propagation limit of captured events on the grab widget"

This reverts commit 6511f411955adba4f960b8b07d39b93785afe33e.

longpress: Use xsettings to determine long press duration

GtkSettings::gtk-long-press-time is used to this effect.

settings: Add gtk-long-press-time setting

This setting determines the duration of a button/touch press to
be considered a long press.

window: Use gestures for window moving/resizing

A multipress gesture is used to control all this, replacing
single/double click custom code, and triggering window dragging
when the multipress is stopped, yet active (ie. the sequence remains
pressed).

treeview: Use multipress gesture for row activation

Replace custom double click detection with multipress gesture

dnd: Use GtkGestureDrag to initiate DnD

This gesture is used by gtk_drag_source_set() to determine
whether dragging moved past the threshold. The gesture events
are handled via the usual ::event callbacks, so we don't mess
up with callers expecting that to happen in a signal handler.

If the sequence gets claimed somewhere else in the event widget
stack, the DnD gesture will be cancelled.

scrolledwindow: Ensure the dragging sequence gets denied if more touches come in

This allows children to receive an emulated press, and handle it together with
the new touch that made the scrolledwindow sequence denied.

scrolledwindow: Fix overshoot coordinates

With gtk_gesture_get_point() returning events in
gtk_event_controller_get_widget() coordinates, we no longer need
to compensate for the overshoot here.

widget: Add gtk_widget_set_gesture_state()

This helper function ensures the state is propagated for
all the active sequences in the given gesture.

widget: Improve button press emulation on sequence denied

Ensure that state being set on pointer emulating touches actually
gets propagated properly on widgets with gestures that only handle
pointer events.

swipe: Dont emit swipe() if the gesture was denied rather than finished

drag: Make API offsets based

It is generally more useful to get offsets right away,
than having to calculate those from the start point.

scrolledwindow: Use GtkGestureSingle API

scrolledwindow: Update gesture API change.

demo: Update to gesture API change

widget: Reset gestures on grab-notify

If it is determined that the gesture will stop receiving
events, reset the gesture altogether.

widget: Make helper gesture API take GtkGestures

GtkEventController may be certainly useful to keep event
handling self-contained in other places than gestures, but
the current widget API is highly related to gestures, so
just using GtkGesture as the argument there will be quite
more convenient. The other places where GtkEventController
make sense as a base object will better provide their own
hooks.

Add: GTK_PHASE_NONE value to GtkCapturePhase.

Gestures attached with this phase will expect callers to have it
receive events through gtk_event_controller_handle_event(), but
the gesture will still be notified of sequence state changes,
grabs, etc...

gesture: check the gesture after denying a sequence.

So the gesture emits end() timely.

gesture: Offer always coordinates in the gesture widget coordinate space

Translate events meant for other widgets/windows, so gtk_gesture_get_point()
always returns coordinates based on the gtk_event_controller_get_widget()
allocation.

multipress: Remove unused signal argument

swipe: Make a subclass of GtkGestureSingle

drag: Make a subclass of GtkGestureSingle

multipress: Make a subclass of GtkGestureSingle

The redundant API has been removed here.

longpress: Make a subclass of GtkGestureSingle

the redundant API here has been removed.

gesture: Only recognize gestures with as many interacting touches as those handled

If a gesture has denied sequences (so those are presumably handled above/below
the widget), it shouldn't attempt to handle extra touches, even if those end
up matching the expected number of touches.

gesture: Limit API calls to non-denied sequences

Gestures do track those internally, but information about those
shouldn't be leaked on calls.

gesture: Require BUTTON_PRESS/TOUCH_BEGIN for sequences to be initiated.

Gestures should always receive one of such events in order to be activated,
and the propagation mechanism will ensure they do so if the original event
was caught up the widget hierarchy by another gesture that is now declining
the sequence.